package com.itheima.controller;

import com.alibaba.dubbo.config.annotation.Reference;
import com.itheima.constant.MessageConstant;
import com.itheima.domain.Role;
import com.itheima.domain.User;
import com.itheima.entity.PageResult;
import com.itheima.entity.QueryPageBean;
import com.itheima.entity.Result;
import com.itheima.service.RoleService;
import com.itheima.service.UserService;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/role")
public class RoleController {
    //从注册中心引用
    @Reference
    private RoleService roleService;

    @Reference
    private UserService userService;

    /**
     * 分页查询
     * @param queryPageBean
     * @return
     */
    @RequestMapping("/findPage")
    public PageResult findPage(@RequestBody QueryPageBean queryPageBean) {
        try{
            //获取当前登录用户
            org.springframework.security.core.userdetails.User loginUser =
                    (org.springframework.security.core.userdetails.User) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
            return roleService.findPage(queryPageBean,loginUser.getUsername());
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 添加角色
     * @param role
     * @param permissionIds
     * @param menuIds
     * @return
     */
    @RequestMapping("/add")//二级路径
    public Result add(@RequestBody Role role, Integer[] permissionIds, Integer[] menuIds) {
        try {
            //判断角色数据格式是否正确,双重保险
            if(role != null && role.getName() != null && role.getKeyword() != null){
                //根据角色名查询数据库是否该角色已存在
                Role target = roleService.findByName(role.getName());
                //根据角色关键字查询数据库是否该角色已存在
                Role target1 = roleService.findByKeyword(role.getKeyword());
                //判断角色是否存在
                if(target == null && target1 == null){
                    //角色不存在，添加角色
                    roleService.add(role, permissionIds,menuIds);
                    //添加成功
                    return new Result(true, MessageConstant.ADD_ROLE_SUCCESS);
                }else {
                    //角色已存在，添加失败
                    return new Result(false, MessageConstant.ADD_ROLE_FAIL1);
                }
            } else {
                //添加失败
                return new Result(false, MessageConstant.ADD_FAIL2);
            }
        } catch (Exception e) {
            e.printStackTrace();
            //添加失败
            return new Result(false, MessageConstant.ADD_ROLE_FAIL);
        }
    }

    /**
     * 根据id查询
     * @param roleId
     * @return
     */
    @RequestMapping("/findById")
    public Result findById(Integer roleId) {
        try{
            //判断roleId是否为空
            if(roleId == null){
                return new Result(false, MessageConstant.QUERY_ROLE_FAIL1);
            }
            //根据id查询角色
            Role role = roleService.findById(roleId);
            //判断角色是否为空
            if (role != null) {
                //角色不为空
                return new Result(true, MessageConstant.QUERY_ROLE_SUCCESS,role);
            } else {
                //该角色不存在
                return new Result(false, MessageConstant.QUERY_ROLE_FAIL2);
            }
        }catch (Exception e){
            e.printStackTrace();
            //出错，返回查询失败
            return new Result(false, MessageConstant.QUERY_ROLE_FAIL);
        }
    }

    /**
     * 根据角色id查询关联数据的数量
     * @param roleId
     * @return
     */
    @RequestMapping("/findCountByRoleId")
    public Result findCountByRoleId(Integer roleId){
        try {
            //判断roleId是否为空
            if(roleId == null){
                return new Result(false, MessageConstant.QUERY_ROLE_FAIL1);
            }
            //根据角色id查询关联数据的数量
            Integer count = roleService.findCountByRoleId(roleId);
            //查询成功 将角色ids作为参数返回
            return new Result(true, MessageConstant.QUERY_ROLE_SUCCESS, count);
        } catch (Exception e){
            e.printStackTrace();
            //出错，返回查询失败
            return new Result(false, MessageConstant.QUERY_COUNT_FAIL);
        }
    }

    /**
     * 根据角色id查询对应的权限id
     * @param roleId
     * @return
     */
    @RequestMapping("/findPermissionIdsByRoleId")
    public Result findPermissionIdsByRoleId(Integer roleId) {
        try {
            //判断roleId是否为空
            if(roleId == null){
                return new Result(false, MessageConstant.QUERY_ROLE_FAIL1);
            }
            //根据角色id查询对应的检查项ids
            List<Integer> permissionIds = roleService.findPermissionIdsByRoleId(roleId);
            //查询成功 将检查项ids作为参数返回
            return new Result(true, MessageConstant.QUERY_PERMISSION_SUCCESS, permissionIds);
        } catch (Exception e) {
            e.printStackTrace();
            //查询失败,返回失败信息
            return new Result(false, MessageConstant.QUERY_PERMISSION_FAIL);
        }
    }

    /**
     * 根据角色id查询对应的菜单id
     * @param roleId
     * @return
     */
    @RequestMapping("/findMenuIdsByRoleId")
    public Result findMenuIdsByRoleId(Integer roleId) {
        try {
            //判断roleId是否为空
            if(roleId == null){
                return new Result(false, MessageConstant.QUERY_ROLE_FAIL1);
            }
            //根据角色id查询对应的检查项ids
            List<Integer> menuIds = roleService.findMenuIdsByRoleId(roleId);
            //查询成功 将检查项ids作为参数返回
            return new Result(true, MessageConstant.QUERY_MENU_SUCCESS, menuIds);
        } catch (Exception e) {
            e.printStackTrace();
            //查询失败,返回失败信息
            return new Result(false, MessageConstant.QUERY_MENU_FAIL);
        }
    }

    /**
     * 删除
     * @param id
     * @return
     */
    @RequestMapping("/delete")
    public Result delete(Integer id) {
        try {
            //判断userId是否为空
            if(id == null){
                return new Result(false, MessageConstant.QUERY_ROLE_FAIL1);
            }
            //根据角色id查询数据库是否该角色已存在
            Role target = roleService.findById(id);
            if(target != null){
                //获取当前登录用户
                org.springframework.security.core.userdetails.User loginUser =
                        (org.springframework.security.core.userdetails.User) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
                //根据用户名获取角色
                User user = userService.findByUsername(loginUser.getUsername());
                if(user != null){
                    //根据用户id获取所有角色
                    List<Integer> roleIdsByUserId = userService.findRoleIdsByUserId(user.getId());
                    //遍历角色
                    for (Integer integer : roleIdsByUserId) {
                        Role role = roleService.findById(integer);
                        if(role != null && target.getName().equals(role.getName())){
                            //角色相同，不允许自己删除自己
                            return new Result(false,MessageConstant.DELETE_ROLE_FAIL1);
                        }
                    }
                }
                //根据ID删除
                roleService.delete(id);
                //删除成功
                return new Result(true, MessageConstant.DELETE_ROLE_SUCCESS);
            } else {
                //角色不存在，删除失败
                return new Result(false, MessageConstant.QUERY_ROLE_FAIL2);
            }
        } catch (Exception e) {
            e.printStackTrace();
            //删除失败
            return new Result(false, MessageConstant.DELETE_ROLE_FAIL);
        }
    }

    /**
     * 修改
     * @param role
     * @param permissionIds
     * @param menuIds
     * @return
     */
    @RequestMapping("/edit")
    public Result edit(@RequestBody Role role, Integer[] permissionIds, Integer[] menuIds) {
        try {
            //判断角色数据格式是否正确,双重保险
            if(role != null && role.getName() != null && role.getKeyword() != null){
                //根据角色id查询数据库是否该角色已存在
                Role target = roleService.findById(role.getId());
                if(target != null) {
                    //获取当前登录用户
                    org.springframework.security.core.userdetails.User loginUser =
                            (org.springframework.security.core.userdetails.User) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
                    //根据用户名获取角色
                    User user = userService.findByUsername(loginUser.getUsername());
                    if (user != null) {
                        //根据用户id获取所有角色
                        List<Integer> roleIdsByUserId = userService.findRoleIdsByUserId(user.getId());
                        //遍历角色
                        for (Integer integer : roleIdsByUserId) {
                            Role roleByUserId = roleService.findById(integer);
                            if (roleByUserId != null && role.getName().equals(roleByUserId.getName())) {
                                //角色相同，禁止使用已有的用户名
                                return new Result(false, MessageConstant.EDIT_ROLE_FAIL2);
                            }
                        }
                    }
                    //禁止使用重复的关键字
                    //获取所有的角色排除自己
                    List<Role> roleList = roleService.findAllExOwn(role.getId());
                    //遍历角色
                    for (Role role1 : roleList) {
                        //获取角色名
                        String name = role1.getName();
                        //获取角色关键字
                        String keyword = role1.getKeyword();
                        //判断用户名是否相同
                        if(name.equals(role.getName())){
                            //该用户名已存在
                            return new Result(false, MessageConstant.EDIT_ROLE_FAIL2);
                        }
                        //判断关键字是否相同
                        if(keyword.equals(role.getKeyword())){
                            //该关键字已存在
                            return new Result(false, MessageConstant.EDIT_ROLE_FAIL1);
                        }
                    }
                    //进行编辑操作
                    roleService.edit(role, permissionIds,menuIds);
                    //编辑成功   返回成功信息
                    return new Result(true, MessageConstant.EDIT_ROLE_SUCCESS);
                } else {
                    //角色不存在，修改失败
                    return new Result(false, MessageConstant.QUERY_ROLE_FAIL2);
                }
            } else {
                //编辑格式错误
                return new Result(false, MessageConstant.EDIT_FAIL2);
            }
        } catch (Exception e) {
            e.printStackTrace();
            //编辑失败  返回失败信息
            return new Result(false, MessageConstant.EDIT_ROLE_FAIL);
        }
    }

    /**
     * 查询所有
     * @return
     */
    @RequestMapping("/findAll")
    public Result findAll() {
        try {
            //执行查询所有操作
            List<Role> list = roleService.findAll();
            //执行成功,将结果作为参数返回
            return new Result(true, MessageConstant.QUERY_ROLE_SUCCESS,list);
        } catch (Exception e) {
            e.printStackTrace();
            //执行失败 返回失败信息
            return new Result(false, MessageConstant.QUERY_ROLE_FAIL);
        }
    }
}
